package com.agritech.strategy;

import com.agritech.environment.EnvironmentData;
import com.agritech.path.PathPlan;
import com.agritech.path.PathPoint;

import java.util.*;

/**
 * A*路径规划策略
 * 实现路径规划策略接口，使用A*算法进行路径规划
 */
public class AStarPathStrategy implements PathPlanningStrategy {
    
    @Override
    public PathPlan calculatePath(EnvironmentData environmentData, 
                                 double startX, double startY, 
                                 double endX, double endY, 
                                 double[][] obstacles) {
        System.out.println("使用A*算法计算从 (" + startX + ", " + startY + ") 到 (" + 
                endX + ", " + endY + ") 的路径");
        
        // 创建路径规划结果对象
        PathPlan pathPlan = new PathPlan();
        pathPlan.setPlanningMethod("A*算法");
        pathPlan.setHasObstacles(obstacles != null && obstacles.length > 0);
        
        // 添加起点
        PathPoint startPoint = new PathPoint(startX, startY, "起点");
        pathPlan.addPathPoint(startPoint);
        
        // 模拟A*算法计算路径
        // 在实际应用中，这里应该实现完整的A*算法
        // 这里为了简化，只是模拟算法的执行过程
        
        // 检查是否有障碍物
        if (obstacles != null && obstacles.length > 0) {
            System.out.println("检测到" + obstacles.length + "个障碍物，计算避障路径");
            
            // 模拟生成避障路径点
            // 在实际应用中，这里应该根据A*算法计算出的路径点
            double midX1 = startX + (endX - startX) * 0.25;
            double midY1 = startY + (endY - startY) * 0.25;
            
            // 假设第一个障碍物在路径中间
            double obstacleX = obstacles[0][0];
            double obstacleY = obstacles[0][1];
            
            // 计算绕过障碍物的点
            double detourX = obstacleX + 5.0; // 假设向右绕行5米
            double detourY = obstacleY;
            
            // 添加中间点
            pathPlan.addPathPoint(new PathPoint(midX1, midY1, "中间点"));
            pathPlan.addPathPoint(new PathPoint(detourX, detourY, "避障点", "绕过障碍物"));
            
            double midX2 = startX + (endX - startX) * 0.75;
            double midY2 = startY + (endY - startY) * 0.75;
            pathPlan.addPathPoint(new PathPoint(midX2, midY2, "中间点"));
        } else {
            // 如果没有障碍物，生成直线路径
            System.out.println("未检测到障碍物，生成直线路径");
            
            // 添加几个中间点，模拟A*算法的路径点
            int numPoints = 3; // 中间点数量
            for (int i = 1; i <= numPoints; i++) {
                double ratio = (double) i / (numPoints + 1);
                double x = startX + (endX - startX) * ratio;
                double y = startY + (endY - startY) * ratio;
                pathPlan.addPathPoint(new PathPoint(x, y, "中间点"));
            }
        }
        
        // 添加终点
        PathPoint endPoint = new PathPoint(endX, endY, "终点");
        pathPlan.addPathPoint(endPoint);
        
        // 根据环境数据调整路径
        adjustPathBasedOnEnvironment(pathPlan, environmentData);
        
        return pathPlan;
    }
    
    /**
     * 根据环境数据调整路径
     * @param pathPlan 路径规划
     * @param environmentData 环境数据
     */
    private void adjustPathBasedOnEnvironment(PathPlan pathPlan, EnvironmentData environmentData) {
        // 根据土壤湿度调整路径
        if (environmentData.getSoilMoisture() > 80) {
            System.out.println("检测到土壤湿度高 (" + environmentData.getSoilMoisture() + 
                    "%)，调整路径以避开湿地区域");
            // 在实际应用中，这里应该根据土壤湿度数据调整路径
            // 这里只是模拟调整过程
        }
        
        // 根据风速调整路径
        if (environmentData.getWindSpeed() > 8.0) {
            System.out.println("检测到强风 (" + environmentData.getWindSpeed() + 
                    "m/s)，调整路径以减少风力影响");
            // 在实际应用中，这里应该根据风速数据调整路径
        }
    }
    
    @Override
    public String getStrategyName() {
        return "A*路径规划算法";
    }
}